package com.ccp.dev.system.service;

import com.ccp.dev.core.basic.base.BaseService;
import com.ccp.dev.core.basic.consts.SystemConst;
import com.ccp.dev.core.basic.util.ContextUtil;
import com.ccp.dev.core.basic.util.UUIDUtils;
import com.ccp.dev.core.util.BeanUtils;
import com.ccp.dev.core.util.StringPool;
import com.ccp.dev.core.util.StringUtil;
import com.ccp.dev.system.dao.SysOrgDao;
import com.ccp.dev.system.dao.SysTenantOrgDao;
import com.ccp.dev.system.dao.SysTenantResourceDao;
import com.ccp.dev.system.model.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;

/**
 * 组织管理模块service
 * @author niudong
 */
@Service
public class SysOrgService extends BaseService<SysOrg> {

    @Resource
    private SysOrgDao sysOrgDao;
    @Resource
    private SysTenantOrgDao sysTenantOrgDao;
    @Resource
    private SysTenantResourceDao sysTenantResourceDao;
    @Resource
    private SysUserService sysUserService;
    @Resource
    private UserPositionService userPositionService;
    @Resource
    private ResourcesService resourcesService;
    @Resource
    private SysTenantDynamicDataService sysTenantDynamicDataService;
    @Resource
    private SysRoleService sysRoleService;
    @Resource
    private RoleResourcesService roleResourcesService;
    @Resource
    private SubSystemService subSystemService;
    @Resource
    private PositionService positionService;
    @Value("${top.org.name}")
    private String TOP_ORG_NAME;
    @Value("${tenant.identify}")
    private String TENANT_IDENTIFY;
    /**
     * 保存和修改
     * @param sysOrg 组织实例
     */
    @Transactional(rollbackFor = Exception.class)
    public void save(SysOrg sysOrg,String systemId) throws Exception {
        String orgId = sysOrg.getOrgId();
        boolean isAdd = false;
        if (StringUtil.isEmpty(orgId)) {
            orgId = UUIDUtils.getUUIDFor32();
            sysOrg.setOrgId(orgId);
            isAdd = true;
        }
        /*
        顶级组织与非顶级组织在拼接path值逻辑不同
         */
        SysOrg supOrg = sysOrgDao.getById(sysOrg.getOrgSupId());
        if (BeanUtils.isEmpty(supOrg)) {
            sysOrg.setPath(SystemConst.TOP_ORG_ID + StringPool.DOT + orgId + StringPool.DOT);
            sysOrg.setOrgPathname(StringPool.SLASH + TOP_ORG_NAME + StringPool.SLASH + sysOrg.getOrgName());
            sysOrg.setIsTenant(SystemConst.TENANT_IDENTIFY);
        } else {
            sysOrg.setPath(supOrg.getPath() + orgId + StringPool.DOT);
            sysOrg.setOrgPathname(supOrg.getOrgPathname() + StringPool.SLASH + sysOrg.getOrgName());
        }
        /*
        新增
         */
        if (isAdd) {
            sysOrg.setCreatorId(ContextUtil.getCurrentUserId());
            sysOrg.setCreateTime(new Date());

            /*
             * 新增租户时需要
             * 1.创建三员
             * 2.创建tenant与org映射 sys_tenant_org
             */

            SysTenantOrg sysTenantOrg = new SysTenantOrg();
            //如果创建的不是租户 则寻找距离该组织最近的租户id
            String tenantId;
            if (sysOrg.getIsTenant()==SysOrg.IS_TENANT_Y){
                //是租户 则直接生成新的租户ID
                tenantId = UUIDUtils.getUUIDFor32();
            }else {
                tenantId = getTenantIdByOrgId(sysOrg.getOrgSupId());
            }
            sysTenantOrg.setTenantId(tenantId);
            sysTenantOrg.setOrgId(orgId);
            sysTenantOrg.setStatus(SystemConst.STATUS_Y);
            sysTenantOrgDao.add(sysTenantOrg);

            sysOrg.setTenantId(sysTenantOrg.getTenantId());

            sysOrgDao.add(sysOrg);

            if (SystemConst.TENANT_IDENTIFY == sysOrg.getIsTenant()) {
                sysUserService.addThreeMember(sysOrg);
                /*
                给租户分配公共资源 sys_tenant_res
                 */
                Map<String, Object> map = new HashMap<>(2);
                map.put("isPublic", SystemConst.PUBLIC_Y);
                map.put("systemId", systemId);
                List<Resources> publicResList = resourcesService.queryPublicResBySystem(map);
                SysTenantResource tr = new SysTenantResource();
                for (Resources res : publicResList) {
                    tr.setTenantResourceId(UUIDUtils.getUUIDFor32());
                    tr.setStatus(SystemConst.STATUS_Y);
                    tr.setResourceId(res.getResId());
                    tr.setTenantId(sysTenantOrg.getTenantId());
                    tr.setSystemId(systemId);
                    sysTenantResourceDao.add(tr);
                }
                //添加默认角色并分配公共资源
                sysRoleService.addDefaultRole(sysOrg,tenantId,systemId,publicResList);

            }
            return;
        }
        /*
        修改
         */
        sysOrg.setUpdateId(ContextUtil.getCurrentUserId());
        sysOrg.setUpdateTime(new Date());
        sysOrgDao.update(sysOrg);
    }

    /**
     * 删除组织
     * @param orgId 要删除的组织id
     * @return
     * 删除成功 返回null
     * 删除失败 返回不能删除的组织名称
     */
    @Transactional(rollbackFor = Exception.class)
    public String delOrgById(String orgId,String systemId) {
        /*
        删除逻辑：
        1 如果本组织存在组织不允许删除
        2.如果本组织存在非三员用户不允许删除
        */
        List<SysOrg> orgList = sysOrgDao.querySubOrgBySupId(orgId);
        if (BeanUtils.isNotEmpty(orgList) && orgList.size() > 0) {
            return "delete.org.failure.exist.subOrg";
        }
        /*
        查询是否存在非三员用户
         */
        boolean isExists = userPositionService.isExistsUser(orgId);
        if (isExists) {
            return "delete.org.failure.exist.user";
        }
        /*
        如果是组织 只删除sys_org、sys_tenant_org表记录
         */
        SysOrg selectOrg = sysOrgDao.getById(orgId);
        String tenantId = sysOrgDao.getTenIdByOrgId(orgId);
        sysOrgDao.delById(orgId);
        sysTenantOrgDao.delByOrgId(orgId);
        /*
        删除组织下岗位
         */
        positionService.delByOrgId(orgId);
        /*
        删除用户与组织关联表数据
         */
        userPositionService.delByOrgId(orgId);
        if(BeanUtils.isNotEmpty(selectOrg) && selectOrg.getIsTenant()!=SystemConst.TENANT_IDENTIFY){
            return null;
        }
        /*
        租户需要删除的关联表：
        */
        Map<String,Object> param = new HashMap<>(2);
        param.put("systemId",systemId);
        param.put("tenantId",tenantId);
        /*
        删除租户资源sys_tenant_res表数据
         */
        sysTenantResourceDao.delByTenantIdAndSystemId(param);
        /*
        删除租户下的角色 SYS_ROLE表数据
         */
        List<SysTenantDynamicData> stdList = sysTenantDynamicDataService.queryByTenantId(tenantId);
        for(SysTenantDynamicData std:stdList){
            sysRoleService.delById(std.getDataId());
        }
        /*
        删除租户角色关联SYS_TENANT_DYNAMIC_DATA表数据
         */
        sysTenantDynamicDataService.delByTenantId(tenantId);
        return null;
    }


    /**
     * 给租户分配资源
     * @param orgId 租户id
     * @param systemId 系统id
     * @param resIds 资源id数组
     */
    @Transactional(rollbackFor = Exception.class)
    public void assignResource(String orgId, String systemId, String[] resIds) {
        /*总体思路：
         *1、获取当前租户的原有资源；
         *2、删除主租户的资源，并重新添加租户与资源的映射关系
         *3、获取当前租户更新后的资源
         *4、当前租户原有资源与更新后的资源进行对比，增加资源没有变化，回收资源存储到params中
         *5、更新子租户数据*/
        /*更新子租户数据思路--递归子组织
         *取出子组织资源映射表与params进行对比，删掉key值与params相同的数据*/
        String tenantId =sysOrgDao.getTenIdByOrgId(orgId);
        Map<String,String> tenantIdAndSystemIdMap = new HashMap<String,String>(1);
        tenantIdAndSystemIdMap.put("tenantId",tenantId);
        tenantIdAndSystemIdMap.put("systemId",systemId);
        List<SysTenantResource> tenantResourcesList = sysTenantResourceDao.queryResourcesByTenantIdAndSystemId(tenantIdAndSystemIdMap);
        /*
        存储主租户id和资源id
         */
        Map<String, String> storeTenantIdAndResourceIdMap=new HashMap<String, String>(1);
        if(BeanUtils.isNotEmpty(tenantResourcesList)){
            for(SysTenantResource tenants:tenantResourcesList){
                storeTenantIdAndResourceIdMap.put(tenants.getResourceId(),tenants.getTenantId());
            }
        }
        /*
         删除主(当前)租户的资源，并重新添加租户与资源的映射关系
         */
        sysTenantResourceDao.delByTenantIdAndSystemId(tenantIdAndSystemIdMap);
        boolean isAddTenantResource = StringUtil.isNotEmpty(systemId) && StringUtil.isNotEmpty(tenantId) && resIds!=null && resIds.length>0;
        Map<String,String> resourceIdAndTenantIdUpdatedMap = new HashMap<String,String>(1);
        if(isAddTenantResource){
            SysTenantResource tenantAndResource=new SysTenantResource();
            Set<String> set = new HashSet<>(Arrays.asList(resIds));
            for(String resourceId:set){
                tenantAndResource.setTenantResourceId(UUIDUtils.getUUIDFor32());
                tenantAndResource.setResourceId(resourceId);
                tenantAndResource.setSystemId(systemId);
                tenantAndResource.setTenantId(tenantId);
                tenantAndResource.setStatus(SystemConst.STATUS_Y);
                resourceIdAndTenantIdUpdatedMap.put(resourceId,tenantId);
                sysTenantResourceDao.add(tenantAndResource);
            }
        }
        /*
        与更新前对比 筛选出被删除的资源与租户映射关系记录
        查询更新后的租户是否回收资源，回收的保存到params里
        三种情况：1、增加资源，没有减少资源，则params为空；2、减少资源，没有增加资源，则params有值；3、资源有减少也有增加，则params也有值。
         */
        Set<String> updatedResourceIds=resourceIdAndTenantIdUpdatedMap.keySet();
        if(BeanUtils.isNotEmpty(updatedResourceIds)){
            for(String resourceId:updatedResourceIds){
                if(storeTenantIdAndResourceIdMap.containsKey(resourceId)){
                    storeTenantIdAndResourceIdMap.remove(resourceId);
                }
            }
        }
        Set<String> removedResourceIdSet = storeTenantIdAndResourceIdMap.keySet();
        /*
         更新子租户数据
         1.查出所有子组织
         2.筛选出租户
         */
        List<SysOrg> subSysOrgList = querySubSysOrgBySupOrgId(orgId);
        int subOrgSize = subSysOrgList.size();
        for(int i=0;i<subOrgSize;i++){
            SysOrg subSysOrg = subSysOrgList.get(i);
            String subTenantId = subSysOrg.getTenantId();
            Map<String,String> subTenantIdAndResource = new HashMap<String,String>(1);
            if(subSysOrg.getIsTenant()==1){
                tenantIdAndSystemIdMap.put("tenantId",subTenantId);
                List<SysTenantResource> subTenResourcesList=sysTenantResourceDao.queryResourcesByTenantIdAndSystemId(tenantIdAndSystemIdMap);
                if(BeanUtils.isNotEmpty(subTenResourcesList)) {
                    for (SysTenantResource tenantResource : subTenResourcesList) {
                        subTenantIdAndResource.put(tenantResource.getResourceId(), tenantResource.getTenantId());
                    }
                }
                if(BeanUtils.isNotEmpty(removedResourceIdSet)){
                    Map<String,String> tenantIdAndSystemIdAndResourceId = new HashMap<String,String>(3);
                    for(String resourceId:removedResourceIdSet){
                        if(subTenantIdAndResource.containsKey(resourceId)){
                            tenantIdAndSystemIdAndResourceId.put("tenantId",subTenantIdAndResource.get(resourceId));
                            tenantIdAndSystemIdAndResourceId.put("systemId",systemId);
                            tenantIdAndSystemIdAndResourceId.put("resourceId",resourceId);
                            sysTenantResourceDao.delByTenantSystemResource(tenantIdAndSystemIdAndResourceId);
                        }
                    }
                }
            }
        }
    }

    /**
     * 根据组织id查找其所有子组织
     * @param orgId 父id
     * @return 所有子租户和组织
     */
    private List<SysOrg> querySubSysOrgBySupOrgId(String orgId) {
        SysOrg org = sysOrgDao.getById(orgId);
        Map<String,String> map = new HashMap<>(2);
        map.put("orgId",orgId);
        map.put("pathLike",org.getPath()+StringPool.PERCENT);
        List<SysOrg> childSysOrgList = sysOrgDao.querySubOrgByPath(map);
        return childSysOrgList;
    }
    /**
     * 根据组织id查找其子组织 只找第一级子组织
     * @param orgId 父id
     * @return 所有子租户和组织
     */
    public List<SysOrg> querySubSysOrgBySupOrgIdNoChild(String orgId) {
        return sysOrgDao.querySubOrgBySupId(orgId);
    }
    /**
     * 根据id查询子组织树
     * @param orgId 组织id
     * @return 组织树
     */
    public List<SysOrg> querySubSysOrgTreeDataBySupOrgId(String orgId){
        List<SysOrg> orgList = sysOrgDao.querySubOrgBySupId(orgId);
        if(orgList!=null){
            for(SysOrg org:orgList){
                org.setTenantId(sysTenantOrgDao.getTenantIdByOrgId(org.getOrgId()));
//                org.setChildren(querySubSysOrgTreeDataBySupOrgId(org.getOrgId()));
            }
        }
        return orgList;
    }

    /**
     * 根据组织id查询子组织带有children的组织树
     * @param orgId
     * @return
     */
    public List<SysOrgChildren> querySubSysOrgTreeDataBySupOrgIdToTree(String orgId){
        List<SysOrgChildren> orgList = sysOrgDao.querySubOrgBySupIdToTree(orgId);
        if(orgList!=null){
            for(SysOrgChildren org:orgList){
                org.setTenantId(sysTenantOrgDao.getTenantIdByOrgId(org.getOrgId()));
                org.setChildren(querySubSysOrgTreeDataBySupOrgIdToTree(org.getOrgId()));
            }
        }
        return orgList;
    }

    /**
     * 根据当前用户id得到组织
     * @param userId 用户
     * @return SysOrg
     */
    public SysOrg getOrgByUserId(String userId){
       return sysOrgDao.getOrgByUserId(userId);
    }

    /**
     * 根据组织id查找组织
     * @param orgId 组织id
     * @return sysOrg
     */
    public SysOrg getSysOrgById(String orgId) {
        return sysOrgDao.getById(orgId);
    }

    /**
     * 根据组织编码查询组织
     * @param orgCode 组织编码
     * @return sysOrg
     */
    public SysOrg getSysOrgByOrgCode(String orgCode){
        return sysOrgDao.getByOrgCode(orgCode);
    }

    /**
     * 根据当前用户 查找其所属租户下所有组织list
     * @param queryMap 查询条件map
     * @return list
     */
    public List<SysOrg> querySysOrgFlat(Map<String,Object> queryMap) {
        SysOrg currentOrg = (SysOrg)queryMap.get("currentOrg");
        List<SysOrg> list = new LinkedList<>();
        list = querySysOrgByOrgSupIdForFlat(queryMap,list,currentOrg);
        if(null!=list && list.size()>0){
            for(SysOrg org:list){
                if(isLeafOrg(org.getOrgId())){
                    org.setIsLeaf(SysOrg.IS_LEAF_Y);
                    org.setIsParentBoolean(true);
                }
            }
        }
        return list;
    }

    /**
     * 根据组织id 查其下所有深度的子组织 返回平铺list（即父、子组织都是list的元素）
     * @param param where条件参数
     * @param list 返回组织平铺list
     * @return 组织集合list
     */
    private List<SysOrg> querySysOrgByOrgSupIdForFlat(Map<String,Object> param,List<SysOrg> list,SysOrg currentOrg){
        if(StringUtil.isNotEmpty((String)param.get("orgId"))){
            String orgId = (String)param.get("orgId");
            /*
            前端是ztree树形列表 父、子组织要作为同级元素存储在同一个list中
             */
            List<SysOrg> tempList = sysOrgDao.querySubOrgBySupId(orgId);
            if(tempList!=null && tempList.size()>0){
                List<SysOrg> needRemoveOrgs = new ArrayList<SysOrg>();
                for(SysOrg org:tempList){
                    if (!SystemConst.SUPER_ADMIN_ID.equals(ContextUtil.getCurrentUserId())) {
                        /*
                        因一个用户只有一个顶级组织 所以移除与当前用户所属顶级组织同级的元素
                         */
                        boolean flag = org.getOrgSupId().equals(currentOrg.getOrgSupId()) && !org.getOrgId().equals(currentOrg.getOrgId());
                        flag = flag && currentOrg.getOrgSupId().equals(orgId) && !currentOrg.getOrgId().equals(org.getOrgId());
                        if (flag) {
                            needRemoveOrgs.add(org);
                            continue;
                        }
                    }
                    param.put("orgId",org.getOrgId());
                    querySysOrgByOrgSupIdForFlat(param,list,currentOrg);
                }
                for(SysOrg removeOrg:needRemoveOrgs){
                    tempList.remove(removeOrg);
                }
                list.addAll(tempList);
            }
        }
        return list;
    }

    /**
     * 组织排序
     * @param lAryId 按顺序排列的同级节点的id数组
     */
    @Transactional(rollbackFor = Exception.class)
    public void updateSn(String[] lAryId) {
        if (BeanUtils.isNotEmpty(lAryId)) {
            Map<String,Object> param = new HashMap<String,Object>(2);
            int sn = 1;
            for (int i = 0; i < lAryId.length; i++) {
                String resId = lAryId[i];
                param.put("orgId",resId);
                param.put("sn",sn++);
                sysOrgDao.updateSn(param);
            }
        }
    }

    /**
     * 根据组织id查询组织是否有子组织
     * @param orgId 组织id
     * @return 返回是否是叶子节点标识 是叶子节点-true 不是叶子节点-false
     */
    private boolean isLeafOrg(String orgId){
        int count = sysOrgDao.querySubOrgByOrgId(orgId);
        return count<=0;
    }
    /**
     * 根据id查询组织树
     * @param orgId 组织id
     * @return 返回组织list 其中每个元素的child属性是该组织的子组织list集合
     */
    public List<SysOrg> querySysOrgTreeDataByOrgId(String orgId) {
        SysOrg sysOrg = this.getOneById(orgId);
        List<SysOrg> orgList = sysOrgDao.queryOrgsByOrgPath(sysOrg.getPath());
        return orgList;
    }

    /**
     * 根据组织id查询带有children的组织树信息
     * @param orgId
     * @return
     */
    public List<SysOrgChildren> querySysOrgTreeDataByOrgIdToTree(String orgId) {
        List<SysOrgChildren> orgList = sysOrgDao.getByIdForTreeDataToTree(orgId);
        orgList.get(0).setTenantId(sysTenantOrgDao.getTenantIdByOrgId(orgId));
        if(orgList!=null){
            for(SysOrgChildren org:orgList){
                org.setChildren(querySubSysOrgTreeDataBySupOrgIdToTree(org.getOrgId()));
            }
        }
        return orgList;
    }

    /**
     * 根据orgId 查其租户id
     * @param orgId 组织id
     * @return 租户id
     */
    public String getTenantIdByOrgId(String orgId) {
        String tenantId = "";
        //先查询该机构是否为租户
        SysOrg sysOrg = sysOrgDao.getById(orgId);
        //如果是租户 则查询关系表获取租户ID
        if (sysOrg.getIsTenant()==SysOrg.IS_TENANT_Y){
            tenantId =  sysTenantOrgDao.getTenantIdByOrgId(sysOrg.getOrgId());
        }else {
            tenantId = getTenantIdByOrgId(sysOrg.getOrgSupId());
        }
        return tenantId;
    }

    /**
     * 根据组织path值查询此组织及其子组织集合
     * @param orgPath 组织path值
     * @return 组织集合list
     */
    public List<SysOrg> queryOrgByPath(String orgPath) {
        List<SysOrg> list = sysOrgDao.queryOrgByPath(orgPath+StringPool.PERCENT);
        if(BeanUtils.isNotEmpty(list) && list.size()>0){
            for(SysOrg org:list){
                if(isLeafOrg(org.getOrgId())){
                    org.setIsLeaf(SysOrg.IS_LEAF_Y);
                    org.setIsParentBoolean(true);
                }
            }
        }
        return list;
    }

    /**
     * 为超管创建顶级组织
     * @return 返回顶级组织
     */
    public SysOrg getTopOrg(){
        SysOrg org=new SysOrg();
        org.setOrgName("租户管理");
        org.setOrgId(SystemConst.TOP_ORG_ID);
        org.setDemId(SystemConst.TOP_ORG_ID);
        org.setOrgSupId(SystemConst.TOP_ORG_SUP_ID.toString());
        org.setIsRoot((short) 1);
        org.setPath(SystemConst.TOP_ORG_ID+".");
        return org;
    }

    /**
     * 校验组织名是否已存在
     * @param orgName 组织名
     * @param orgId 当前组织id
     * @return 若存在 返回true 不存在返回false
     */
    public boolean isExistsOrgName(String orgName,String orgId) {
        SysOrg org = sysOrgDao.getByOrgName(orgName);
        if(BeanUtils.isNotEmpty(org) && !org.getOrgId().equals(orgId)){
            return true;
        }
        return false;
    }

    /**
     * 校验组织代码是否已存在
     * @param orgCode 组织代码
     * @param orgId 当前组织id
     * @return 若存在 返回true 不存在返回false
     */
    public boolean isExistsOrgCode(String orgCode,String orgId) {
        SysOrg org = sysOrgDao.getByOrgCode(orgCode);
        if(BeanUtils.isNotEmpty(org)&& !org.getOrgId().equals(orgId)){
            return true;
        }
        return false;
    }

    /**
     * 根据角色id获取组织
     * @param roleId 角色id
     * @return 返回组织对象
     */
    public SysOrg getOrgByRoleId(String roleId){
       return sysOrgDao.getOrgByRoleId(roleId);
    }

    /**
     * 通过组织id返回租户id
     * @param orgId
     * @return
     */
    public String getTenIdByOrgId(String orgId) {
        String tentId = sysOrgDao.getTenIdByOrgId(orgId);
        if (tentId != null) {
            return tentId;
        }
        return null;
    }

    /**
     * 根据租户id,查询对应的租户
     * @param tenantId
     * @return
     */
    public SysOrg getOrgByTenId(String tenantId) {
        return sysOrgDao.getOrgByTenantId(tenantId);
    }

    /**
     * 获取组织信息
     * @return
     */
    public List<SysOrg> queryAll () {
        return sysOrgDao.queryAll();
    }

    /**
     * 通过组织id返回上级租户id(递归实现)
     * @param orgId
     * @return
     */
    public String getSuperTenantIdByOrgId(String orgId){
        String tenantId = getTenIdByOrgId(orgId);
        if(StringUtil.isEmpty(tenantId)){
            tenantId = getSuperTenantIdByOrgId(getSysOrgById(orgId).getOrgSupId());
        }
        return tenantId;
    }

    public List<SysOrg> queryOrgsByUserId(String userId) {
        return sysOrgDao.queryOrgsByUserId(userId);
    }

    /**
     * 根据组织的名称查询组织数据
     * @param name
     * @return
     */
    public List<SysOrg> queryByOrgName(String name) {
        return sysOrgDao.queryByOrgName(name);
    }


    /**
     * 根据orgId 查其租户id
     *
     * @param orgId 组织id
     * @return 租户id
     */
    public String getTenantItByOrgId(String orgId) {
        return sysOrgDao.getTenIdByOrgId(orgId);
    }

    /**
     * 根据租户ID 获取 租户组织
     *
     * @param tenantId
     * @return
     */
    public SysOrg getTenantOrgByTenantId(String tenantId) {
        return sysOrgDao.getTenantOrgByTenantId(tenantId);
    }

    public List<SysOrg> queryTenantByOrgName(String orgName, String tenantId) {
        Map<Object, Object> map = new HashMap<Object, Object>();
        map.put("orgName", orgName);
        map.put("tenantId", tenantId);
        return sysOrgDao.queryTenantByOrgName(map);
    }

    public List<SysOrg> queryOrgByorgSupId(String orgName, String orgSupId) {
        Map<Object, Object> map = new HashMap<Object, Object>();
        map.put("orgName", orgName);
        map.put("orgSupId", orgSupId);
        return sysOrgDao.queryOrgByorgSupId(map);
    }

    /**
     * 根据租户Ids 查询 租户组织
     * @param tenantIds
     * @return
     */
    public List<SysOrg> queryTenantOrgByTentanIds(List<String> tenantIds) {
        if(tenantIds != null && tenantIds.size() > 0){
            return sysOrgDao.queryTenantOrgByTentanIds(tenantIds);
        }
        return new ArrayList<>();
    }

    public List<SysOrg> queryOrgsByOrdIds(List<String> orgIds) {
        if(orgIds != null && orgIds.size() > 0){
            return sysOrgDao.queryOrgsByOrdIds(orgIds);
        }
        return new ArrayList<>();
    }
}
